import  PointPath = require('./../../common/graph/PointPath');
import  GroupObj = require('./../obj/GroupObj');
import Parser = require('./../base/Parser');

var CONFIG=require('../../../../common/config');
export  = SJGReplaceGroupAdvance;

/**
 *
 * @author 
 *
 */
class SJGReplaceGroupAdvance {
    // ［0表示不显示连接线／1表示根据扩展方式显示(例如圆形扩展显示圆弧)／2表示显示直线连接/3表示自定义图形
    public static CONNECT_NONE: number=0;
    public static CONNECT_ARC: number=1;
    public static CONNECT_LINE: number=2;
    public static CONNECT_PATH: number=3;
    
    // ［水平扩展／垂直扩展时有效］尾行对齐方式：1.靠左/考上  2.居中  3.靠右/靠下
    public static TAIL_POS_0=0;
    public static TAIL_POS_1=1;
    public static TAIL_POS_2=2;
    public static TAIL_POS_3=3;
    
    // ［矩形对角线扩展时有效］
    // 对角线类型 1表示左上到右下 2表示右上到左下
    public static DIAGONAL_0=0; // 无
    public static DIAGONAL_1=1;
    public static DIAGONAL_2=2; 
    // 内部编组的位置： 1表示内部编组在对角线左侧 2表示右侧 3表示左右交错 4表示右左交错
    public static DIAGONAL_ALIGN_0=0; // 无
    public static DIAGONAL_ALIGN_1=1;
    public static DIAGONAL_ALIGN_2=2;
    public static DIAGONAL_ALIGN_3=3;
    public static DIAGONAL_ALIGN_4=4;
    // 强制对齐模式的类型：0无强制对齐／1抬头强制对齐到锚点／2图片强制对齐到锚点
    public static FORCE_ALIGN_NONE=0;
    public static FORCE_ALIGN_TEXT_HEAD=1;
    public static FORCE_ALIGN_IMAGE=2;
    
    
    // 高级属性
    public extend_style: number=0;
    
    public extend_method: number=0;
    public count: number=1; // [冗余字段]元素的个数
    
    public connect: number=SJGReplaceGroupAdvance.CONNECT_NONE;// 是否显示内部对象之间的连接线
    public connect_path: GroupObj=null;// 内部对象之间的连接对象 GroupObj，这些对象不需要存入对象管理器
    
    public force_align: number=SJGReplaceGroupAdvance.FORCE_ALIGN_NONE;// 强制对齐模式的类型
    
    // ［水平扩展／垂直扩展时有效］
    public limit: number=null; // ［水平扩展／垂直扩展时有效］水平扩展一行的最大列数，垂直扩展一列的最大行数，其它类型无效
    public tail_pos: number=null; //［水平扩展／垂直扩展时有效］ 尾行的排列方式，见SJGReplaceGroupAdvance.TAIL_POS_*
    
    // ［矩形对角线扩展时有效］
    public diagonal: number=null;//［矩形对角线扩展时有效］1表示左上到右下 2表示右上到左下
    public diagonal_align: number=null;// ［矩形对角线扩展时有效］1表示内部编组在对角线左侧 2表示右侧 3表示左右交错 4表示右左交错
    
    public constructor(g?) {
        
	}
	    
    // 从json对象(注意不是json字符串)中解析
    public fromJson(jsonObj,versionId) {

        this.extend_style = jsonObj.extend_style * 1;
        this.extend_method = jsonObj.extend_method * 1;
        this.count=jsonObj.count*1;
        if(jsonObj.hasOwnProperty('connect')) {
            this.connect=jsonObj.connect;
        }

        if(jsonObj.hasOwnProperty('connect_path')) {
            this.connect_path=Parser.fromUnknownJson(jsonObj.connect_path,versionId);
        }
        if(jsonObj.hasOwnProperty('force_align')) {
            this.force_align=jsonObj.force_align;
        }
        
        if(jsonObj.hasOwnProperty('limit')) {
            this.limit=jsonObj.limit*1;
        }
        
        if(jsonObj.hasOwnProperty('tail_pos')){
            this.tail_pos=jsonObj.tail_pos*1;
        }
        
        if(jsonObj.hasOwnProperty('diagonal')) {
            this.diagonal=jsonObj.diagonal*1;
        }
        if(jsonObj.hasOwnProperty('diagonal_align')) {
            this.diagonal_align=jsonObj.diagonal_align*1;
        }
       
    }
    
    // 转成json字符串
    public toJson(): string {

        var ret = '{';
        
        // extend_style
        ret += '"extend_style":';
        ret += this.extend_style;
        
        // extend_method
        ret += ',';
        ret += '"extend_method":';
        ret += this.extend_method;
        
        // count
        ret+=',';
        ret+='"count":';
        ret+=this.count;
        
        // connect
        ret+=',';
        ret+='"connect":';
        ret+=this.connect;
      
        // connect_path
        if(this.connect_path) {
            ret+=',';
            ret+='"connect_path":';
            ret+=this.connect_path.toJson();
        }
        // force_align
        ret+=',';
        ret+='"force_align":';
        ret+=this.force_align;
        
       
        // limit
        if(this.limit){
            ret+=',';
            ret+='"limit":';
            ret+=this.limit;            
        }
        
        // tail_pos
        if(this.tail_pos){
            ret+=',';
            ret+='"tail_pos":';
            ret+=this.tail_pos;            
        }
        // diagonal
        if(this.diagonal) {
            ret+=',';
            ret+='"diagonal":';
            ret+=this.diagonal;
        }
        
        // diagonal_align
        if(this.diagonal_align) {
            ret+=',';
            ret+='"diagonal_align":';
            ret+=this.diagonal_align;
        }
        
       
        // tail
        ret += '}';
        return ret;
    }
    
    // 拷贝对象
    public copy():SJGReplaceGroupAdvance{
        var ret: SJGReplaceGroupAdvance=new SJGReplaceGroupAdvance();
        ret.fromJson(JSON.parse(this.toJson()),0);
        return ret;
    }
    
    // 获取显示用信息
    public getShowInfo():string {
        
        var extdM = (this.extend_method == 0) ? "水平扩展":(
            (this.extend_method == 1) ? "垂直扩展" : (
                (this.extend_method == 2) ? "圆形扩展" : (
                    (this.extend_method == 3) ? "W形扩展" : (
                        (this.extend_method == 4) ? "按路径扩展" : ""))));
        if (extdM.length>0) {
            extdM = '['+extdM+'] ';
        }
              
        var aliPt='';
        if(this.tail_pos && this.limit){
            var aliPtStr=(this.tail_pos==SJGReplaceGroupAdvance.TAIL_POS_0)? "尾行对齐方式:无":(
                (this.tail_pos==SJGReplaceGroupAdvance.TAIL_POS_1)? "尾行对齐方式:左/上":(
                    (this.tail_pos==SJGReplaceGroupAdvance.TAIL_POS_2)? "尾行对齐方式:居中":"尾行对齐方式:右/下"));
            if(aliPtStr.length>0) {
                aliPt='['+aliPtStr+' limit:'+this.limit+'] ';
            }            
        }
        var dia='';
        if(this.diagonal&&this.diagonal_align){
            // 对角线类型 1表示左上到右下 2表示右上到左下
            // 内部编组的位置： 1表示内部编组在对角线左侧 2表示右侧 3表示左右交错 4表示右左交错
            var diaStr=(this.diagonal==SJGReplaceGroupAdvance.DIAGONAL_0)? "无":(
                (this.diagonal==SJGReplaceGroupAdvance.DIAGONAL_1)? "左上到右下":"表示右上到左下");
            var diaAlignStr=(this.diagonal_align==SJGReplaceGroupAdvance.DIAGONAL_ALIGN_0)? "无":(
                (this.diagonal_align==SJGReplaceGroupAdvance.DIAGONAL_ALIGN_1)? "对角线左侧":(
                    (this.diagonal_align==SJGReplaceGroupAdvance.DIAGONAL_ALIGN_2)? "对角线右侧":(
                        (this.diagonal_align==SJGReplaceGroupAdvance.DIAGONAL_ALIGN_3)? "左右交错":"右左交错")));
            if(diaStr.length>0&&diaAlignStr.length>0) {
                dia='['+diaStr+' '+diaAlignStr+'] ';
            }     
            
        }
        
    
        return extdM+aliPt+dia;
    }
    
    // 对数据进行合法性验证，修改不合理部分
    // 返回错误消息,null表示正常
    public validate():string{
        var ret: string=null;
        // 去除无用数据
        if(this.extend_method!=0&&this.extend_method!=1){
            this.limit=null;
            this.tail_pos=null;
        }
        
        if(this.extend_method!=3) {
            this.diagonal=null;
            this.diagonal_align=null;
        }
        // 进行合法性验证
        switch(this.extend_method){
            case 0:
            case 1:
                {
                    if(this.limit==null){
                        ret="水平／垂直扩展的limit为空";
                    }else{
                        if(this.tail_pos==null){
                            ret="水平／垂直扩展的尾行对齐方式为空";
                        }
                    }
                }
                break;
            case 3:
                {
                    if(this.diagonal==null){
                        ret="矩形对角线扩展的类型为空";
                    } else {
                        if(this.diagonal_align==null) {
                            ret="矩形对角线扩展的内部编组对齐方式为空";
                        }
                    }
                }
                break;
        }
        
        return ret;
    }
//SJG_MARK_APPEND--------------------

}//SJG_MARK_END-------------------------
